home *** CD-ROM | disk | FTP | other *** search
/ Mac Format 1994 October / Macformat17.cdr / Shareware City / Developers / shutdown-fx-20-c / sfx control app ƒ / Shell ƒ / menus.c < prev    next >
Text File  |  1994-07-11  |  8KB  |  303 lines
  1. /**********************************************************************\
  2.  
  3. File:        menus.c
  4.  
  5. Purpose:    This module handles menu selections.
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program in a file named "GNU General Public License".
  19. If not, write to the Free Software Foundation, 675 Mass Ave,
  20. Cambridge, MA 02139, USA.
  21.  
  22. \**********************************************************************/
  23.  
  24. #include "graphics.h"
  25. #include "menus.h"
  26. #include "help.h"
  27. #include "environment.h"
  28. #include "error.h"
  29. #include "file interface.h"
  30. #include "debinhex dispatch.h"
  31. #include "file management.h"
  32. #include "program globals.h"
  33. #include "sfx main window.h"
  34.  
  35. MenuHandle        gAppleMenu;
  36. MenuHandle        gFileMenu;
  37. MenuHandle        gEditMenu;
  38. MenuHandle        gOptionsMenu;
  39.  
  40. enum
  41. {
  42.     appleMenu = 400, fileMenu, editMenu, optionsMenu,
  43.     
  44.     aboutItem = 1, aboutMSGItem, helpPointerItem,
  45.     
  46.     openItem=1, closeItem, file_unused1, deBinHexItem, file_unused2,
  47.         quitItem,
  48.     
  49.     undoItem = 1, cutItem = 3, copyItem, pasteItem, clearItem, selectAllItem,
  50.     
  51.     kRestartOnly=1, kShutdownOnly, kRestartAndShutdown, kNever, kRescanForModules
  52. };
  53.  
  54. /*-----------------------------------------------------------------------------------*/
  55. /* internal stuff for menus.c                                                        */
  56.  
  57. void HandleAppleMenu(short menuItem);
  58. void HandleFileMenu(short menuItem);
  59. void HandleEditMenu(short menuItem);
  60. void HandleHelpMenu(void);
  61. void HandleOptionsMenu(short menuItem);
  62.  
  63. Boolean InitTheMenus(void)
  64. {
  65.     Handle        MBARHandle;
  66.     
  67.     if ((MBARHandle=GetNewMBar(400))==0L)        /* sez which menus are in menu bar. */
  68.         return FALSE;
  69.     SetMenuBar(MBARHandle);                        /* set this to be THE menu bar to use. */
  70.     
  71.     if ((gAppleMenu=GetMHandle(appleMenu))==0L)    /* GetNewMBar also got menu handles of */
  72.         return FALSE;
  73.     if ((gFileMenu=GetMHandle(fileMenu))==0L)    /* every menu it includes, so just */
  74.         return FALSE;
  75.     if ((gEditMenu=GetMHandle(editMenu))==0L)    /* grab these handles and assign them */
  76.         return FALSE;
  77.     if ((gOptionsMenu=GetMHandle(optionsMenu))==0L)
  78.         return FALSE;
  79.         
  80.     AddResMenu(gAppleMenu, 'DRVR');                /* adds control panels to apple menu */
  81.     
  82.     AdjustMenus();                                /* dim/enable/check/mark menus/items */
  83.     DrawMenuBar();                                /* draws the actual menu bar */
  84.     
  85.     return TRUE;
  86. }
  87.  
  88. void AdjustMenus(void)
  89. {
  90.     WindowPeek        theWindow;
  91.     short            kind;
  92.     
  93.     if (gInProgress)
  94.     {
  95.         DisableItem(gAppleMenu, aboutItem);
  96.         DisableItem(gAppleMenu, aboutMSGItem);
  97.         DisableItem(gAppleMenu, helpPointerItem);
  98.         DisableItem(gFileMenu, 0);
  99.         DisableItem(gEditMenu, 0);
  100.         DisableItem(gOptionsMenu, 0);
  101.     }
  102.     else
  103.     {
  104.         EnableItem(gAppleMenu, aboutItem);
  105.         EnableItem(gAppleMenu, aboutMSGItem);
  106.         EnableItem(gAppleMenu, helpPointerItem);
  107.         EnableItem(gFileMenu, 0);
  108.         EnableItem(gEditMenu, 0);
  109.         EnableItem(gOptionsMenu, 0);
  110.         
  111.         theWindow = (WindowPeek)FrontWindow();
  112.         kind = theWindow ? theWindow->windowKind : 0;
  113.         
  114.         if (kind < 0)
  115.         {
  116.             EnableItem(gEditMenu, undoItem);
  117.             EnableItem(gEditMenu, cutItem);
  118.             EnableItem(gEditMenu, copyItem);
  119.             EnableItem(gEditMenu, pasteItem);
  120.             EnableItem(gEditMenu, clearItem);
  121.         }
  122.         else
  123.         {
  124.             DisableItem(gEditMenu, undoItem);
  125.             DisableItem(gEditMenu, cutItem);
  126.             DisableItem(gEditMenu, copyItem);
  127.             DisableItem(gEditMenu, pasteItem);
  128.             DisableItem(gEditMenu, clearItem);
  129.         }
  130.         
  131.         if(theWindow)
  132.             EnableItem(gFileMenu, closeItem);
  133.         else
  134.             DisableItem(gFileMenu, closeItem);
  135.         
  136.         if (GetIndWindowGrafPtr(kMainWindow))
  137.             DisableItem(gFileMenu, openItem);
  138.         else
  139.             EnableItem(gFileMenu, openItem);
  140.     }
  141.     
  142.     SetItemMark(gOptionsMenu, kRestartOnly, (gOnRestart && !gOnShutdown) ? '◊' : noMark);
  143.     SetItemMark(gOptionsMenu, kShutdownOnly, (!gOnRestart && gOnShutdown) ? '◊' : noMark);
  144.     SetItemMark(gOptionsMenu, kRestartAndShutdown, (gOnRestart && gOnShutdown) ? '◊' : noMark);
  145.     SetItemMark(gOptionsMenu, kNever, (!gOnRestart && !gOnShutdown) ? '◊' : noMark);
  146. }
  147.  
  148. void HandleMenu(long mSelect)
  149. {
  150.     short            menuID = HiWord(mSelect);
  151.     short            menuItem = LoWord(mSelect);
  152.     
  153.     switch (menuID)
  154.     {
  155.         case appleMenu:
  156.             HandleAppleMenu(menuItem);
  157.             break;
  158.         case fileMenu:
  159.             HandleFileMenu(menuItem);
  160.             break;    
  161.         case editMenu:
  162.             HandleEditMenu(menuItem);
  163.             break;
  164.         case optionsMenu:
  165.             HandleOptionsMenu(menuItem);
  166.             break;
  167.     }
  168. }
  169.  
  170. void DoTheCloseThing(WindowPeek theWindow)
  171. /* a standard close procedure, called when "close" is chosen from File menu and when
  172.    a window is closed through its close box */
  173. {
  174.     Boolean            gotone;
  175.     short            i;
  176.     short            kind;
  177.     
  178.     if (theWindow==0L)
  179.         return;
  180.     
  181.     kind = theWindow ? theWindow->windowKind : 0;
  182.     if (kind<0)        /* DA window or other system window */
  183.         CloseDeskAcc(kind);
  184.     else
  185.     {
  186.         gotone=FALSE;
  187.         /* see if it's one of ours */
  188.         for (i=0; (i<NUM_WINDOWS) && (!gotone); i++)
  189.             gotone=((WindowPtr)theWindow==GetIndWindowGrafPtr(i));
  190.         
  191.         if (gotone)        /* if it's one of ours...  see graphics.c */
  192.             CloseTheIndWindow(i-1);            /* this may return FALSE = not closed */
  193.         else
  194.             DisposeWindow((WindowPtr)theWindow);    /* not one of ours, so just close it */
  195.     
  196.         AdjustMenus();    /* may affect which menu items or menus are available, etc */
  197.     }
  198. }
  199.  
  200. void HandleAppleMenu(short menuItem)
  201. {
  202.     GrafPtr        savePort;
  203.     Str255        name;
  204.     
  205.     switch (menuItem)
  206.     {
  207.         case aboutItem:
  208.             OpenTheIndWindow(kAbout);
  209.             break;
  210.         case aboutMSGItem:
  211.             OpenTheIndWindow(kAboutMSG);
  212.             break;
  213.         case helpPointerItem:
  214.             HandleHelpMenu();
  215.             break;
  216.         default:
  217.             if (menuItem > helpPointerItem+1)
  218.             {
  219.                 GetPort(&savePort);
  220.                 GetItem(gAppleMenu, menuItem, name);
  221.                 OpenDeskAcc(name);
  222.                 SetPort(savePort);
  223.             }
  224.             break;
  225.     }
  226. }
  227.  
  228. void HandleFileMenu(short menuItem)
  229. {
  230.     WindowPtr            theWindow;
  231.     short                i;
  232.     Boolean                gotone;
  233.     
  234.     switch (menuItem)
  235.     {
  236.         case openItem:
  237.             OpenTheIndWindow(kMainWindow);
  238.             break;
  239.         case closeItem:
  240.             DoTheCloseThing((WindowPeek)FrontWindow());
  241.             break;
  242.         case deBinHexItem:
  243.             if (GetSourceFile(&inputFS, TRUE, FALSE))
  244.             {
  245.                 SetErrorParameters("\pFile: ", inputFS.name, "\p");
  246.                 HandleError(DeBinHexDispatch(), FALSE, TRUE);
  247.             }
  248.             break;
  249.         case quitItem:
  250.             gDone = TRUE;
  251.             break;
  252.     }
  253. }
  254.  
  255. void HandleEditMenu(short menuItem)
  256. {
  257.     if (gFrontWindowIsOurs)
  258.     {
  259.         switch (menuItem)
  260.         {
  261.             case undoItem:        CallIndDispatchProc(gFrontWindowIndex, kUndo, 0L);    break;
  262.             case cutItem:        CallIndDispatchProc(gFrontWindowIndex, kCut, 0L);    break;
  263.             case copyItem:        CallIndDispatchProc(gFrontWindowIndex, kCopy, 0L);    break;
  264.             case pasteItem:        CallIndDispatchProc(gFrontWindowIndex, kPaste, 0L);    break;
  265.             case clearItem:        CallIndDispatchProc(gFrontWindowIndex, kClear, 0L);    break;
  266.             case selectAllItem:    CallIndDispatchProc(gFrontWindowIndex, kSelectAll, 0L);    break;
  267.         }
  268.     }
  269.     else SystemEdit(menuItem-1);
  270. }
  271.  
  272. void HandleHelpMenu(void)
  273. {
  274.     OpenTheIndWindow(kHelp);
  275. }
  276.  
  277. void HandleOptionsMenu(short menuItem)
  278. {
  279.     switch (menuItem)
  280.     {
  281.         case kRestartOnly:
  282.             gOnRestart=TRUE;
  283.             gOnShutdown=FALSE;
  284.             break;
  285.         case kShutdownOnly:
  286.             gOnRestart=FALSE;
  287.             gOnShutdown=TRUE;
  288.             break;
  289.         case kRestartAndShutdown:
  290.             gOnRestart=gOnShutdown=TRUE;
  291.             break;
  292.         case kNever:
  293.             gOnRestart=gOnShutdown=FALSE;
  294.             break;
  295.         case kRescanForModules:
  296.             if (!GetIndWindowGrafPtr(kMainWindow))
  297.                 OpenTheIndWindow(kMainWindow);
  298.             else
  299.                 HandleError(MakeNewLists(TRUE), TRUE, FALSE);
  300.             break;
  301.     }
  302. }
  303.